import { PrismaClient } from '@prisma/client';
import { getCurrentTimeInShanghai } from '../src/utils';

const prisma = new PrismaClient();

async function main() {
    console.log('开始迁移角色数据...');

    // 1. 获取所有旧的角色数据
    const oldRoles = await prisma.sysDict.findMany({
        where: { dict_type: 'sys_user_role', del_flag: 1 },
    });

    if (oldRoles.length === 0) {
        console.log('没有需要迁移的角色数据。');
        return;
    }

    console.log(`发现 ${oldRoles.length} 个角色需要迁移。`);

    // 2. 获取所有权限定义的映射
    const permissions = await prisma.sysDict.findMany({
        where: { dict_type: 'sys_permission', del_flag: 1 },
    });
    const permissionMap = new Map(permissions.map(p => [p.dict_id, p.id]));
    console.log(`加载了 ${permissionMap.size} 个权限定义。`);


    for (const oldRole of oldRoles) {
        try {
            console.log(`\n正在迁移角色: "${oldRole.dict_name}" (旧ID: ${oldRole.id})`);

            // 3. 检查新表中是否已存在同名角色
            const existingNewRole = await prisma.sysRole.findUnique({
                where: { role_key: oldRole.dict_id },
            });

            if (existingNewRole) {
                console.log(`角色 "${oldRole.dict_name}" 已存在于新表中，跳过创建。`);
                continue;
            }

            // 4. 在 sys_role 表中创建新角色
            const currentTime = getCurrentTimeInShanghai();
            const newRole = await prisma.sysRole.create({
                data: {
                    role_name: oldRole.dict_name,
                    role_key: oldRole.dict_id,
                    description: oldRole.description,
                    status: 1, // 默认为启用状态
                    create_time: oldRole.create_time || currentTime,
                    update_time: oldRole.update_time || currentTime,
                    del_flag: 1
                },
            });
            console.log(` -> 成功创建新角色: "${newRole.role_name}" (新ID: ${newRole.id})`);


            // 5. 解析并迁移权限
            let oldPermissions: string[] = [];
            if (oldRole.other) {
                try {
                    const otherData = JSON.parse(oldRole.other);
                    if (Array.isArray(otherData.permissions)) {
                        oldPermissions = otherData.permissions;
                    }
                } catch (e) {
                    console.error(` -> 解析角色 "${oldRole.dict_name}" 的 other 字段失败, 跳过权限迁移。`, e);
                }
            }
            
            if (oldPermissions.length === 0) {
                console.log(` -> 角色 "${oldRole.dict_name}" 没有关联的权限。`);
                continue;
            }

            console.log(` -> 发现 ${oldPermissions.length} 个关联权限，正在迁移...`);

            // 6. 创建角色与权限的关联
            for (const permKey of oldPermissions) {
                const permissionId = permissionMap.get(permKey);
                if (permissionId) {
                    await prisma.sysRolePermissionLink.create({
                        data: {
                            role_id: newRole.id,
                            permission_id: permissionId,
                        },
                    });
                    console.log(`    - 关联权限 "${permKey}" 成功。`);
                } else {
                    console.warn(`    - 警告: 未找到权限key为 "${permKey}" 的权限定义，无法关联。`);
                }
            }

            // 7. （可选）更新旧表中的角色状态，标记为已迁移
            await prisma.sysDict.update({
                where: { id: oldRole.id },
                data: { del_flag: 0, description: `[已迁移] ${oldRole.description || ''}` },
            });
            console.log(` -> 成功标记旧角色为已迁移。`);


        } catch (error) {
            console.error(`迁移角色 "${oldRole.dict_name}" 时发生错误:`, error);
        }
    }

    console.log('\n角色数据迁移完成！');
}

main()
    .catch((e) => {
        console.error(e);
        process.exit(1);
    })
    .finally(async () => {
        await prisma.$disconnect();
    }); 